package Gradle基础;
/*
Gradle Java应用程序

	我们可以使用Gradle的 Build Init plugin 创建一个新的Java应用程序来跟踪Gradle约定。 Build插件提供了一个名为 init 的任务，该任务可以生成项
目。该插件还使用包装器任务创建Gradle包装器脚本( gradlew )。

要使用Gradle创建Java应用程序，请执行以下步骤:

第1步  - 第一步是为新项目创建目录，并将目录更改为该目录。
	遵循以下命令创建一个名为Java_application的目录:
	mkdir java_application
	遵循以下命令将命令行目录更改为该目录:
	cd Java_application  

第2步  - 运行 init命令创建一个新的Gradle项目:
	gradle init

第3步 - 选择要生成的项目类型。有四个可用的命令行选项，如下所示:
	1.basic
	2.application
	3.library
	4.Gradle plugin
	输入2并按Enter键创建一个应用(application)程序。默认选择为基本。

第4步  - 选择实现语言。共有五个选项，如下所示:
	1.C ++
	2.Groovy
	3.Java
	4.Kotlin
	5.Swift
	键入3，然后按Enter键(对于Java)。默认选择是Java。

第5步 - 下一步是为项目选择默认的构建脚本语言。有两个选项，如下所示:
	1.Groovy
	2.Kotlin
	键入1并按Enter键以选择Groovy。默认选择是Groovy。

第6步 - 选择测试框架。测试框架有四个可用选项。它们如下:
	1.JUnit 4
	2.TestNG
	3.Spock
	4.JUnit Jupiter
	输入您的选择。默认选择是JUnit 4。

第7步 - 输入项目名称(project name)；默认情况下，它将目录名称作为项目名称。

第8步 - 输入源程序包(source package)；默认情况下，它将目录名称作为源包。

现在，init任务已成功执行，并且我们已经使用Gradle Init API创建了Java应用程序。

考虑以下输出:

init任务本身包含包装器任务，因此首先执行包装器任务，该任务在我们的存储库中生成 gradlew 和 gradlew.bat 文件(包装器脚本)。它创建具有以下结构
的Gradle项目:

f:\java_application
      |---.gradle
   	|     |---7.3.3
	   |     |     |--chechsums
	   |     |     |     |---checksums.lock
      |     |     |---dependencies-accessors
      |     |     ...
      |     |---buildOutputCleanup
      |     |     ...
      |     |---vcs-1
      |           ...
      |---app       
      |    |---build
      |    |      |---classes   项目的已编译 .class 文件
      |    |      |      |---java
      |    |      |        ...  
	   |    |      |---distributions
	   |    |      |        |---app.tar
	   |    |      |        |---app.zip
   	|    |      |---generated
	   |    |      |        |---sources
	   |    |      |           ...
	   |    |      |---libs       组装的项目库（通常是 JAR 和/或 WAR 文件）
	   |    |      |    |---app.jar(Executable Jar File)
	   |    |      |---reports    构建所产生的报告（例如测试报告）
	   |    |      |    ...
	   |    |      |---scripts
	   |    |      |    ...
	   |    |      |---test-results
	   |    |      |    ...
	   |    |      |---tmp
	   |    |           ...
	   |    |---src
	   |    |    |---main
	   |    |    |    |---java  (2.默认Java源文件夹)
	   |    |    |    |    |---java_application
	   |    |    |    |              |---App.java
	   |    |    |    |---resources
	   |    |    |---test
	   |    |         |---java  (3.默认Java测试文件夹)
	   |    |         |    |---java_application
	   |    |         |              |---AppTest.java
	   |    |         |---resources
	   |    |---build.gradle
	   |---gradle   (1.包含包装文件的生成的包装程序包。)
	   |    |---wrapper
	   |          |---gradle-wrapper.jar(Executable Jar File)
	   |          |---gradle-wrapper.properties(Properties源文件)
	   |---.gitattributes.txt
	   |---.gitignore.txt
	   |---gradlew.
	   |---gradlew.bat
	   |---settings.gradle

secondGradle
├── app
│   ├── build.gradle
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── secondGradle
│       │   │       └── App.java
│       │   └── resources
│       └── test
│           ├── java
│           │   └── secondGradle
│           │       └── AppTest.java
│           └── resources
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle



上面的结构描述:

1.包含包装文件的生成的包装程序包。
2.默认Java源文件夹
3.默认Java测试文件夹

《生成文件》
让我们看一下项目的生成文件（settings.gradle）。它设置根项目的名称。

rootProject.name = 'Java_application'
include('app')

它将使用默认行为，即在项目所在的目录之后对其进行命名。看起来像:

Gradle Java Application
它是Gradle项目的构建脚本。生成的build.gradle文件包含许多组件。在此构建脚本中介绍了所使用的依赖关系及其版本。生成的构建文件的内容如下:

plugins {
    id 'java'
    id 'application'
}
repositories {
    jcenter() //public bintray artifactory repository
}
dependencies {
    implementation 'com.google.guava:guava:27.1-jre' //Google Guava Library
    testImplementation 'junit:junit:4.12' //JUnit testing library
}
application {
    mainClassName = 'Java_application.App'//class with the main method used by Gradle plugin 
}


以下是实际内容：
plugins {
    // Apply the application plugin to add support for building a CLI application in Java.
    id 'application'
}

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
}

dependencies {
    // Use JUnit Jupiter for testing.
    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'

    // This dependency is used by the application.
    implementation 'com.google.guava:guava:30.1.1-jre'
}

application {
    // Define the main class for the application.
    mainClass = 'java_application.App'
}

tasks.named('test') {
    // Use JUnit Platform for unit tests.
    useJUnitPlatform()
}

Gradle构建脚本添加了Java和应用程序插件。当我们运行gradle命令时，它将在Gradle的构建脚本中搜索。

Gradle支持Java项目，并且包含一个具有main方法的类，该类可以从命令行执行。在Java_Application中，主类的名称为 App 。

文件App.java位于目录 Java_application\src\main\java\Java_application 中。 App.java的生成代码如下:
(文件App.java位于目录 Java_application\app\src\main\java\Java_application 中。 App.java的生成代码如下:)

package Java_application;
public class App {
    public String getGreeting() {
        return "Hello world.";
    }
    public static void main(String[] args) {
        System.out.println(new App().getGreeting());
    }
}
上面的Java源文件是由init任务生成的。

它是Java项目的测试类。测试类在目录 Java_application\src\test\java\Java_application 中进行。 AppTest.java的生成代码如下:
(它是Java项目的测试类。测试类在目录 Java_application\app\src\test\java\Java_application 中进行。 AppTest.java的生成代码如下:)

package Java_application;
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
    @Test public void testAppHasAGreeting() {
        App classUnderTest = new App();
        assertNotNull("app should have a greeting", classUnderTest.getGreeting());
    }
}
init任务生成给定的Java测试文件。生成的测试文件包含单个测试，该测试带有JUnit的@test注释。此测试实例化App类，调用 getGreeting()，并检查返回的
值是否不为null。

执行构建
要执行gradle构建，请与gradlew命令一起运行构建任务。但是，我们可以运行gradle任务，但是最好包含wrapper脚本。

gradlew build
输出:

Gradle Java Application
构建任务将编译类，运行测试并创建测试报告。

Note: 第一次运行gradlew命令时，可能需要一些时间，而指定版本的gradle是在本地下载和存储的。
Gradle包装器脚本检查我们是否已指定Guava和JUnit库，如果未指定，则它将下载并将其存储在/.gradle目录中。

运行程序
gradle构建使用应用程序插件，因此我们可以从命令行运行该应用程序。 gradlew run 命令将用于从命令行运行应用程序。

首先，使用task命令显示插件添加的任务:

gradlew tasks
上面的命令将列出项目中的可用任务。考虑下面的输出:

Gradle Java Application
现在，使用run命令运行该应用程序。它将传达Gradle以执行分配给 mainClassName 属性的类中的main方法。

gradlew run
输出:

Hello world.

《build》
使用 build 可以构建整个 Java 项目,将输出很多项目构建时产生的文件.

gradle build
:compileJava
:processResources NO-SOURCE
:classes
:jar
:startScripts
:distTar
:distZip
:assemble
:compileTestJava
:processTestResources NO-SOURCE
:testClasses
:test
:check
:build

BUILD SUCCESSFUL in 2s
7 actionable tasks: 7 executed

运行完成之后,将会在项目根目录下生成 build 目录.
该项目 .jar 文件存放在 build/libs/ 目录下.
可以打开 build\reports\tests\test\index.html 文件查看测试报告.

《打包 .jar》
当前若只想打包 .jar 文件,只需要执行 gradlew jar 即可. 但是这里需要注意打包出来的 jar 包是不能直接运行的, 想要打包可运行的 jar 需要
在 build.gradle 中加入:

jar {
    manifest {
        attributes 'Main-Class': 'App'
    }
    archiveName "java-demo.jar"
}
增加清单文件属性 'Main-class', 属性值为类的全包名 com.raise.xxx.Main.
archiveName 指定jar包的名称.
若注释有中文, 还需要指定编码:

tasks.withType(JavaCompile) {
    options.encoding = "UTF-8"
}
build 目录不需要我们手动删除,下次构建时会自动删除旧文件.若想清除 build, 可以使用 clean 命令.

《clean》
gradlew clean
:clean

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

该命令将会删除当前 project 的 build 目录,若执行该任务失败,也可手动在磁盘上删除 build 目录,不会影响项目构建.*/
